/* eslint-disable */
const fs = require('fs');
const path = require('path');
const glob = require('glob');

const {
  replaceFileChineseWithI18n
} = require('./test-regex');
const { parseJSONWithDuplicates, addMultipleKeyValuesToJsonPath } = require('./jsonHelper');

// 获取 zh.json、en.json 和 checkRepeat.json 的路径
const zhJsonPath = path.join(__dirname, './src/locale/zh.json');
const enJsonPath = path.join(__dirname, './src/locale/en.json');
const checkZhJsonPath = path.join(__dirname, 'checkRepeat.json');
const translateFilePath = path.join(__dirname, './translateFile.json');
const translateTempPath = path.join(__dirname, './translateTemp.json');

const replaceOption = {
  // 配置项：指定哪些符号可以用来拆分中文句子
  // 例如：设置为 ['，', '。'] 可以将一句中文按逗号和句号拆分
  splitSymbols: [],
  // 是否排除比较语句中的中文（如 === '状态'）
  excludeComparisonChinese: true,
  // 国际化前缀，用于生成国际化key
  keyPrefix: 'page.asset.',
  // 模块key，用于生成国际化key
  moduleKey: 'communityManagement',
  // 优先匹配路径
  matchChineseKeyPath: ['common', 'message', 'page'],
  // 提取中文时是否忽略末尾冒号
  skipColon: true
}

// 项目根目录路径
const rootDir = __dirname;

// 递归遍历对象，构建中文到 key 全路径的映射
function buildReverseMap (obj, prefix = '', result = {}) {
  const addToResult = (key, value) => {
    if (result[value]) {
      if (typeof result[value] === 'string') {
        result[value] = [result[value]]
      }
      result[value].push(key)
    } else {
      result[value] = key
    }
  }
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      const fullKey = prefix ? `${prefix}.${key}` : key;
      let value = obj[key]

      if (typeof value === 'string') {
        value = value.replace(/^[\s\u3000\p{P}]+|[\s\u3000\p{P}]+$/gu, '')
        addToResult(fullKey, value)
      } else if (Array.isArray(value)) {
        value.forEach(val => {
          addToResult(fullKey, val)
        })
      } else if (typeof value === 'object' && value !== null) {
        buildReverseMap(value, fullKey, result);
      }
    }
  }
  return result;
}

// 创建或更新 checkRepeat.json 文件
function updateCheckZhJson (b = true) {
  if (!fs.existsSync(checkZhJsonPath)) {
    fs.writeFileSync(checkZhJsonPath, JSON.stringify({}, null, 2), 'utf8');
    console.log('checkRepeat.json 文件已创建');
  }

  try {
    // 读取 zh.json 文件
    const zhJsonContent = fs.readFileSync(zhJsonPath, 'utf8');
    const zhJson = parseJSONWithDuplicates(zhJsonContent);

    // 构建反向映射
    const reverseMap = buildReverseMap(zhJson);

    // 写入 checkRepeat.json 文件
    fs.writeFileSync(checkZhJsonPath, JSON.stringify(reverseMap, null, 2), 'utf8');
    b && console.log('checkRepeat.json 文件已更新');
  } catch (error) {
    b && console.error('更新 checkRepeat.json 文件时出错:', error);
  }
}

// 检查中文字符串是否存在翻译key，并返回对应的 key 路径
// 匹配时忽略开头和末尾的标点符号:：！!。，、；‘’“”（）【】《》
// 支持传入单个字符串或字符串数组
function findKeyByChinese (chineseText, b = true) {
  updateCheckZhJson(false);
  try {
    // 读取 checkRepeat.json 文件
    const checkZhJsonContent = fs.readFileSync(checkZhJsonPath, 'utf8');
    const checkZhJson = JSON.parse(checkZhJsonContent);

    const matchChineseKeyPath = replaceOption.matchChineseKeyPath.concat([`${replaceOption.keyPrefix}${replaceOption.moduleKey}`])

    const getMatch = (text, zhJson) => {
      const textLocal = text.replace(/^[\s\u3000\p{P}]+|[\s\u3000\p{P}]+$/gu, '')
      if (zhJson[textLocal]) {
        if (Array.isArray(zhJson[textLocal])) {
          return zhJson[textLocal].find(zh => matchChineseKeyPath.some(key => zh.match(new RegExp(`^${key}\\.\\w+$`)))) || zhJson[textLocal][0];
        }
        return zhJson[textLocal];
      }
      return false;
    }


    // 如果传入的是数组，返回一个对象包含所有匹配结果
    if (Array.isArray(chineseText)) {
      const result = {
        'needToTranslate': {},
        'doNotTranslate': {},
      };
      chineseText.forEach(text => {
        const zh = getMatch(text, checkZhJson);
        if (zh) {
          result.doNotTranslate[text] = zh
        } else {
          result.needToTranslate[text] = text;
        }
      });
      b && console.log(JSON.stringify(result, null, 2));
      return result;
    }

    // 如果传入的是单个字符串，保持原有逻辑
    // 首先尝试完全匹配
    let textLocal = chineseText.replace(/\s+/g, '');
    textLocal = getMatch(textLocal, checkZhJson);
    b && console.log(textLocal);
    return textLocal;
  } catch (error) {
    b && console.error('读取 checkRepeat.json 文件时出错:', error);
    return false;
  }
}

// 检查文件是否存在，不存在则创建
function checkTranslateFile () {
  if (!fs.existsSync(translateFilePath)) {
    fs.writeFileSync(translateFilePath, JSON.stringify({ "fileDirs": [], "zh": {}, "cache": {} }, null, 2), 'utf8');
  }
  console.log('translateFile.json 文件已创建');

  if (!fs.existsSync(translateTempPath)) {
    fs.writeFileSync(translateTempPath, JSON.stringify({
      "zh": [],
      "en": [],
      "key": []
    }, null, 2), 'utf8');
  }
  console.log('translateTemp.json 文件已创建');
}

// 处理translateFile.json文件，删除'en'对象，添加'cache'对象
function processTranslateFile () {
  try {
    // 读取文件内容
    const translateFileContent = fs.readFileSync(translateFilePath, 'utf8');
    const translateFile = JSON.parse(translateFileContent);

    // 删除'en'对象
    if (translateFile.en) {
      delete translateFile.en;
    }

    // 确保'zh'对象存在
    if (!translateFile.zh) {
      translateFile.zh = {};
    }

    // 创建'cache'对象
    if (!translateFile.cache) {
      translateFile.cache = {};
    }
    // 遍历'zh'对象，按key的前两个字段分组
    for (const key in translateFile.zh) {
      if (translateFile.zh.hasOwnProperty(key)) {
        const keyParts = key.split('.');
        if (keyParts.length >= 2) {
          const groupKey = keyParts.slice(0, 2).join('.');
          if (!translateFile.cache[groupKey]) {
            translateFile.cache[groupKey] = {};
          }
          translateFile.cache[groupKey][key] = translateFile.zh[key];
        }
      }
    }

    delete translateFile.zh;

    fs.writeFileSync(translateFilePath, JSON.stringify(translateFile, null, 2), 'utf8');
    // 写入文件
    console.log('translateFile.json 文件已更新');

    return checkCacheTranslations();
  } catch (error) {
    console.error('处理 translateFile.json 文件时出错:', error);
  }
}

function clearCache () {

  try {
    // 写入文件
    fs.writeFileSync(translateFilePath, JSON.stringify({
      "fileDirs": [],
      "cache": {}
    }, null, 2), 'utf8');
    console.log('translateFile.json 文件中的cache已清空');
    return {};
  } catch (error) {
    console.error('检查cache翻译时出错:', error);
    return {};
  }
}

// 检查cache中的中文翻译是否存在已有翻译key
function checkCacheTranslations () {
  try {
    // 读取translateFile.json文件
    const translateFileContent = fs.readFileSync(translateFilePath, 'utf8');
    const translateFile = JSON.parse(translateFileContent);

    const translateTempContent = fs.readFileSync(translateTempPath, 'utf8');
    const translateTemp = JSON.parse(translateTempContent);

    if (translateTemp.zh && translateTemp.en && translateTemp.zh.length > 0 && translateTemp.en.length > 0) {
      if (!replaceOption.moduleKey) {

        console.error('检查cache翻译时出错:', `moduleKey不能为空`);
        throw new Error('moduleKey不能为空');
      }
      const zhKeyValuePairs = []
      const enKeyValuePairs = []
      translateTemp.zh.forEach((item, i) => {
        if (translateTemp.en[i] && translateTemp.key[i]) {
          zhKeyValuePairs.push({ key: `${translateTemp.key[i]}`, value: translateTemp.zh[i] })
          enKeyValuePairs.push({ key: `${translateTemp.key[i]}`, value: translateTemp.en[i] })
        }
      })
      const result = addMultipleKeyValuesToJsonPath(zhJsonPath, `${replaceOption.keyPrefix}${replaceOption.moduleKey}`, zhKeyValuePairs);
      if (result) {
        console.log('zh.json添加键值对成功');
      } else {
        console.log('zh.json添加键值对失败');
      }

      const result2 = addMultipleKeyValuesToJsonPath(enJsonPath, `${replaceOption.keyPrefix}${replaceOption.moduleKey}`, enKeyValuePairs);
      if (result2) {
        console.log('en.json添加键值对成功');
      } else {
        console.log('en.json添加键值对失败');
      }
      updateCheckZhJson(false);
    }

    translateTemp.zh = [];
    translateTemp.en = [];
    translateTemp.key = [];
    fs.writeFileSync(translateTempPath, JSON.stringify(translateTemp, null, 2), 'utf8');

    // 确保cache对象存在
    if (!translateFile.cache) {
      console.log('cache对象不存在，请先运行processTranslateFile()函数');
      return {};
    }

    // 收集所有cache中的中文值（过滤掉已经是翻译key的值）
    const allChineseValues = [];
    for (const groupKey in translateFile.cache) {
      if (translateFile.cache.hasOwnProperty(groupKey)) {
        const group = translateFile.cache[groupKey];
        for (const key in group) {
          if (group.hasOwnProperty(key)) {
            const value = group[key];
            // 第一层过滤：检查是否为字符串且不是翻译key
            if (value && typeof value === 'string' && /[\u4e00-\u9fa5]/.test(value)) {
              allChineseValues.push(value);
            }
          }
        }
      }
    }

    // 使用findKeyByChinese检查是否存在翻译
    const result = findKeyByChinese(allChineseValues, false);

    // 替换cache中对应的中文值为翻译key
    for (const groupKey in translateFile.cache) {
      if (translateFile.cache.hasOwnProperty(groupKey)) {
        const group = translateFile.cache[groupKey];
        for (const key in group) {
          if (group.hasOwnProperty(key)) {
            const chineseValue = group[key];
            if (result.doNotTranslate[chineseValue]) {
              group[key] = result.doNotTranslate[chineseValue];
            }
          }
        }
      }
    }

    // 写入文件
    fs.writeFileSync(translateFilePath, JSON.stringify(translateFile, null, 2), 'utf8');
    console.log('translateFile.json 文件中的cache已更新翻译key');

  } catch (error) {
    console.error('检查cache翻译时出错:', error);
    return { needToTranslate: {} };
  }
}

// 根据文件路径匹配cache分组
function matchFilePathWithCache (filePath, translateFile) {
  try {
    // 获取文件名（不含扩展名）和路径信息
    const fileName = path.basename(filePath, path.extname(filePath));
    const filePathParts = filePath.split(path.sep);

    // 创建一个评分系统，找到最佳匹配的分组
    let bestMatch = null;
    let highestScore = 0;

    // 遍历cache对象，查找匹配的分组
    for (const groupKey in translateFile.cache) {
      if (translateFile.cache.hasOwnProperty(groupKey)) {
        const keyParts = groupKey.split('.');

        // 基础分数：如果第二部分与文件名匹配
        let score = 0;

        // 检查文件名匹配
        if (keyParts.length >= 2 && keyParts[1] === fileName) {
          score += 10; // 文件名匹配给10分

          // 检查路径匹配
          // 尝试在文件路径中查找与groupKey第一部分匹配的目录名
          const moduleNamePart = keyParts[0];
          let pathMatchScore = 0;

          for (let i = 0; i < filePathParts.length; i++) {
            // 检查路径部分是否与模块名匹配（不区分大小写和下划线/连字符）
            const normalizedPathPart = filePathParts[i].toLowerCase().replace(/[-_]/g, '');
            const normalizedModulePart = moduleNamePart.toLowerCase().replace(/[-_]/g, '');

            // 完全匹配得分最高
            if (normalizedPathPart === normalizedModulePart) {
              pathMatchScore = 10;
              break;
            }
            // 包含关系得分次之
            else if (normalizedPathPart.includes(normalizedModulePart)) {
              pathMatchScore = Math.max(pathMatchScore, 8);
            }
            else if (normalizedModulePart.includes(normalizedPathPart)) {
              pathMatchScore = Math.max(pathMatchScore, 5);
            }
          }

          // 特别处理：如果文件路径中包含与groupKey第一部分完全相同的目录名
          // 例如：bill分组应该优先匹配bill目录下的文件
          const pathString = filePath.toLowerCase();
          if (pathString.includes('\\' + moduleNamePart.toLowerCase() + '\\')) {
            pathMatchScore = 15; // 路径中有完全匹配的目录名，给予更高分数
          }

          score += pathMatchScore;

          // 如果分数高于当前最高分，更新最佳匹配
          if (score > highestScore) {
            highestScore = score;
            bestMatch = {
              groupKey,
              translations: translateFile.cache[groupKey],
              score
            };
          }
        }
      }
    }

    // 如果找到匹配，返回最佳匹配
    if (bestMatch) {
      console.log(`找到匹配的分组: ${bestMatch.groupKey}，匹配分数: ${bestMatch.score}`);
      return {
        groupKey: bestMatch.groupKey,
        translations: bestMatch.translations
      };
    }

    console.log(`未找到与文件 ${filePath} 匹配的分组`);
    return null;
  } catch (error) {
    console.error('匹配文件路径与cache分组时出错:', error);
    return null;
  }
}

// 搜索文件夹下所有文件，替换文件中的中文为i18n key并返回未翻译中文needToTranslate
function searchAndReplaceFiles (customFileDirs) {
  updateCheckZhJson(false);
  checkTranslateFile();

  try {
    let translateFile = '';
    // 如果没有提供自定义目录，尝试从translateFile.json文件中读取fileDirs字段
    try {
      // 首先尝试从项目根目录的translateFile.json读取
      if (fs.existsSync(translateFilePath)) {
        const translateFileContent = fs.readFileSync(translateFilePath, 'utf8');
        translateFile = JSON.parse(translateFileContent);
      }

      // 如果根目录没有找到，尝试从src/i18n/temp/translateFile.json读取
      if (!translateFile) {
        const tempTranslateFilePath = path.join(rootDir, 'src', 'i18n', 'temp', 'translateFile.json');
        if (fs.existsSync(tempTranslateFilePath)) {
          const tempTranslateFileContent = fs.readFileSync(tempTranslateFilePath, 'utf8');
          translateFile = JSON.parse(tempTranslateFileContent);
        }
      }
    } catch (readError) {
      console.error('读取translateFile.json时出错:', readError);
    }

    // 确保'zh'对象存在
    if (!translateFile.zh) {
      translateFile.zh = {};
    }

    let fileDirs = customFileDirs;
    if (!fileDirs && translateFile.fileDirs && translateFile.fileDirs.length > 0) {
      fileDirs = translateFile.fileDirs;
    }

    if (!fileDirs) {
      return {
        success: true,
        matchedFiles: 0,
        updatedFiles: 0,
        fileList: [],
        needToTranslate: []
      };
    }

    const results = [];
    const updatedFiles = [];
    let needToTranslate = [];

    // 确保fileDirs是数组
    const dirs = Array.isArray(fileDirs) ? fileDirs : [fileDirs];
    // 遍历每个目录
    dirs.forEach(dir => {

      // 确保目录路径使用正确的路径分隔符
      const normalizedDir = dir.replace(/\\/g, '/');
      let files = []
      try {
        if (fs.statSync(dir).isDirectory()) {

          // 使用glob查找目录下所有js和vue文件
          const pattern = `${normalizedDir}/**/*.{js,vue}`;
          files = glob.sync(pattern);
          console.log(`在目录 ${dir} 中找到 ${files.length} 个文件，使用模式: ${pattern}`);

          // 如果没有找到文件，尝试使用不同的模式
          if (files.length === 0) {
            const altPattern = path.join(dir, '**', '*.js').replace(/\\/g, '/');
            const jsFiles = glob.sync(altPattern);

            const altPattern2 = path.join(dir, '**', '*.vue').replace(/\\/g, '/');
            const vueFiles = glob.sync(altPattern2);

            const allFiles = [...jsFiles, ...vueFiles];
            console.log(`尝试替代模式: ${altPattern} 和 ${altPattern2}，找到 ${allFiles.length} 个文件`);

            if (allFiles.length > 0) {
              files.push(...allFiles);
            }
          }
        } else if (fs.statSync(dir).isFile()) {
          files.push(dir);
        }
      } catch (error) {
        console.error(`处理目录 ${dir} 时出错:`, error);
      }

      // 对每个文件进行匹配
      files.forEach(file => {
        const matchResult = matchFilePathWithCache(file, translateFile)
        if (matchResult) {
          const replaceResult = replaceKeysInFile(file, matchResult.translations);
          needToTranslate = needToTranslate.concat(replaceResult.needToTranslate);
        }
        const result = replaceFileChineseWithI18n(file, { ...replaceOption }, findKeyByChinese);

        if (result.success) {
          results.push(result);

          // 检查result.needToTranslate是否为数组
          if (Array.isArray(result.needToTranslate)) {
            needToTranslate = needToTranslate.concat(result.needToTranslate.reduce((acc, cur) => acc.concat(Object.keys(cur)), []))
          } else if (typeof result.needToTranslate === 'object') {
            // 如果是对象，直接获取其键
            needToTranslate = needToTranslate.concat(Object.keys(result.needToTranslate))
          }

          for (const key in result.needToTranslate) {
            if (result.needToTranslate.hasOwnProperty(key)) {
              const value = result.needToTranslate[key];
              translateFile.zh[value] = key;
            }
          }

          // 如果内容有变化，写入文件
          if (result.replaced) {
            updatedFiles.push(file);

            if (!translateFile.fileDirs.includes(file)) {
              translateFile.fileDirs.push(file);
            }
          }
        } else {
          if (!translateFile.fileDirs.includes(file)) {
            translateFile.fileDirs.push(file);
          }
          console.error(`文件 ${file} 更新错误: ${result.message}`);
        }
      });
    });

    fs.writeFileSync(translateFilePath, JSON.stringify(translateFile, null, 2), 'utf8');

    needToTranslate = [...new Set(needToTranslate)].slice(0, 30).map(key => key.replace('"', '\"'));

    processTranslateFile();

    // 读取文件内容
    const translateTempContent = fs.readFileSync(translateTempPath, 'utf8');
    const translateTemp = JSON.parse(translateTempContent);
    translateTemp.zh = needToTranslate;
    translateTemp.en = [];
    translateTemp.key = [];
    fs.writeFileSync(translateTempPath, JSON.stringify(translateTemp, null, 2), 'utf8');

    return {
      success: true,
      matchedFiles: results.length,
      updatedFiles: updatedFiles.length,
      fileList: updatedFiles,
      needToTranslate: needToTranslate
    };
  } catch (error) {
    console.error('搜索文件并替换key时出错:', error);
    return { success: false, message: error.message };
  }
}

// 保留单独的替换文件方法，以便在需要时单独使用
function replaceKeysInFile (filePath, translations) {
  try {
    // 读取文件内容
    const fileContent = fs.readFileSync(filePath, 'utf8');

    const needToTranslate = [];

    // 创建新的内容
    let newContent = fileContent;

    // 遍历translations对象，替换key为value
    for (const key in translations) {
      if (translations.hasOwnProperty(key)) {
        const value = translations[key];
        // 使用正则表达式替换key
        if (!value.match(/[\u4e00-\u9fff]+/)) {
          const keyRegex = new RegExp(`${key.replace(/\./g, '\\.')}(['"])`, 'g');
          newContent = newContent.replace(keyRegex, `${value}$1`);
        } else {
          needToTranslate.push(value);
        }
      }
    }

    // 如果内容有变化，写入文件
    if (newContent !== fileContent) {
      fs.writeFileSync(filePath, newContent, 'utf8');
      console.log(`文件 ${filePath} 已更新`);
      return { success: true, needToTranslate };

    } else {
      console.log(`文件 ${filePath} 无需更新`);
      return { success: false, needToTranslate };
    }
  } catch (error) {
    console.error(`替换文件 ${filePath} 中的key时出错:`, error);
    return { success: false, needToTranslate: [] };
  }
}

// 处理命令行参数
if (require.main === module) {
  const args = process.argv.slice(2);
  const command = args[0];

  switch (command) {
    case 'updateCheckZhJson':
      updateCheckZhJson();
      break;
    case 'findKeyByChinese':
      const chineseTexts = args.slice(1);
      if (chineseTexts.length === 0) {
        console.log('请提供要查找的中文文本');
      } else {
        const result = findKeyByChinese(chineseTexts);
        console.log(JSON.stringify(result, null, 2));
      }
      break;
    case 'processTranslateFile':
      const processResult = processTranslateFile();
      console.log(JSON.stringify(processResult, null, 2));
      break;
    case 'checkTranslateFile':
      checkTranslateFile();
      break;
    case 'checkCacheTranslations':
      const checkResult = checkCacheTranslations();
      console.log(JSON.stringify(checkResult, null, 2));
      break;
    case 'clearCache':
      clearCache();
      break;
    case 'matchFilePathWithCache':
      if (args.length < 2) {
        console.log('请提供文件路径');
      } else {
        const filePath = args[1];
        const matchResult = matchFilePathWithCache(filePath);
        console.log(JSON.stringify(matchResult, null, 2));
      }
      break;
    case 'searchAndReplaceFiles':
      // 可以接受自定义目录参数，如果没有提供则从translateFile.json中读取
      const customDir = args.length > 1 ? args[1] : null;
      const searchAndReplaceResult = searchAndReplaceFiles(customDir);
      console.log(JSON.stringify(searchAndReplaceResult, null, 2));
      break;
    case 'searchFilesAndMatchCache':
      console.log('searchFilesAndMatchCache 命令已被合并到 searchAndReplaceFiles 命令中，请使用 searchAndReplaceFiles 命令代替');
      if (args.length < 2) {
        console.log('请提供要搜索的目录');
      } else {
        const dirs = args.slice(1);
        const searchResult = searchAndReplaceFiles(dirs);
        console.log(JSON.stringify(searchResult, null, 2));
      }
      break;
    case 'replaceKeysInFile':
      if (args.length < 3) {
        console.log('请提供文件路径和分组名');
      } else {
        const filePath = args[1];
        const groupKey = args[2];

        // 读取translateFile.json文件
        const translateFileContent = fs.readFileSync(translateFilePath, 'utf8');
        const translateFile = JSON.parse(translateFileContent);

        // 确保cache对象和指定的分组存在
        if (!translateFile.cache || !translateFile.cache[groupKey]) {
          console.log(`cache对象或分组 ${groupKey} 不存在`);
        } else {
          const translations = translateFile.cache[groupKey];
          const replaceResult = replaceKeysInFile(filePath, translations);
          console.log(`替换结果: ${replaceResult}`);
        }
      }
      break;
    default:
      console.log(`
        支持的命令:
          updateCheckZhJson - 更新checkRepeat.json文件
          checkTranslateFile - 检查translateFile.json文件和translateTemp.json文件
          findKeyByChinese [中文1] [中文2] ... - 查找中文对应的翻译key
          processTranslateFile - 处理translateFile.json文件
          checkCacheTranslations - 检查cache中的中文翻译是否存在已有翻译key
          clearCache - 清空cache中的中文翻译
          matchFilePathWithCache [文件路径] - 匹配文件路径与cache分组
          searchAndReplaceFiles [可选:目录] - 搜索文件并替换key为value（如不提供目录则从translateFile.json读取）
          replaceKeysInFile [文件路径] [分组名] - 替换文件中的key为对应的value
          addKeyValueToJsonPath [JSON文件路径] [键路径] [新键名] [新值] - 向JSON文件的指定路径添加新的键值对
          addMultipleKeyValuesToJsonPath [JSON文件路径] [键路径] [键1] [值1] [键2] [值2] ... - 向JSON文件的指定路径一次性添加多个键值对
    `);
  }
}

// 导出函数
module.exports = {
  updateCheckZhJson,
  findKeyByChinese,
  processTranslateFile,
  clearCache,
  checkCacheTranslations,
  matchFilePathWithCache,
  searchAndReplaceFiles,
  replaceKeysInFile
};
